// 等待DOM加载完成
document.addEventListener('DOMContentLoaded', function() {
    // 从URL获取所有车辆参数
    const urlParams = getCarParamsFromUrl();
    console.log('从URL获取的车辆参数:', urlParams);
    
    // 如果有carId参数且为有效数字，可以根据参数加载车辆信息
    if (urlParams.carId && !isNaN(urlParams.carId)) {
        loadCarDetails(urlParams);
    } else {
        console.log('没有从URL中获取到有效的carId参数');
    }
    
    // 为返回按钮添加点击事件
    const backButton = document.querySelector('.back-btn');
    if (backButton) {
        backButton.addEventListener('click', function() {
            window.location.href = 'index.html';
        });
    }
    
    // 为确认预约按钮添加点击事件
    const submitButton = document.querySelector('.submit-btn');
    if (submitButton) {
        submitButton.addEventListener('click', handleReservationSubmit);
    }
    
    // 设置日期输入框的相互限制
    setupDateInputConstraints();
    
    // 页面加载时初始化租金显示
    updateRentalInformation();
});

/**
 * 计算两个日期之间的天数差（只计算日期，不计算时间）
 * @param {string} startDate - 开始日期（YYYY-MM-DD格式）
 * @param {string} endDate - 结束日期（YYYY-MM-DD格式）
 * @returns {number} 天数差
 */
function calculateDaysDifference(startDate, endDate) {
    try {
        const start = new Date(startDate);
        const end = new Date(endDate);
        
        // 只比较日期部分，忽略时间
        start.setHours(0, 0, 0, 0);
        end.setHours(0, 0, 0, 0);
        
        const timeDiff = end.getTime() - start.getTime();
        return Math.ceil(timeDiff / (1000 * 3600 * 24));
    } catch (error) {
        console.error('计算日期差时发生错误:', error);
        return 0;
    }
}

/**
 * 计算总租金
 * @param {number} dailyRate - 日租金
 * @param {number} days - 租用天数
 * @returns {number} 总租金
 */
function calculateTotalRentalCost(dailyRate, days) {
    return dailyRate * days;
}

/**
 * 更新页面上的租用天数和总租金显示
 */
function updateRentalInformation() {
    try {
        // 获取日期输入框的值
        const pickupDateInput = document.querySelector('input[type="date"]');
        const returnDateInput = document.querySelectorAll('input[type="date"]')[1];
        
        if (!pickupDateInput || !returnDateInput) {
            console.warn('未找到日期输入框元素');
            return;
        }
        
        const pickupDate = pickupDateInput.value;
        const returnDate = returnDateInput.value;
        
        // 获取日租金（从URL参数或页面显示中获取）
        let dailyRate = 0;
        const urlParams = getCarParamsFromUrl();
        if (urlParams.dailyRate && urlParams.dailyRate > 0) {
            dailyRate = urlParams.dailyRate;
        } else {
            // 尝试从页面价格显示中获取日租金
            const priceValue = document.querySelector('.price-value');
            if (priceValue) {
                const priceText = priceValue.textContent;
                const match = priceText.match(/¥(\d+(\.\d{1,2})?)/);
                if (match && match[1]) {
                    dailyRate = parseFloat(match[1]);
                }
            }
        }
        
        // 获取总金额显示元素
        const totalRowLabel = document.querySelector('.total-row .total-label');
        const totalRowValue = document.querySelector('.total-row .total-value');
        const totalAmountValue = document.querySelector('.total-amount div:last-child');
        
        if (!totalRowLabel || !totalRowValue || !totalAmountValue) {
            console.warn('未找到总金额显示元素');
            return;
        }
        
        // 如果两个日期都已选择且合理，则计算天数和总租金
        if (pickupDate && returnDate && pickupDate <= returnDate) {
            const rentalDays = calculateDaysDifference(pickupDate, returnDate);
            // 确保天数为正数
            const validDays = rentalDays > 0 ? rentalDays : 0;
            const totalCost = calculateTotalRentalCost(dailyRate, validDays);
            
            // 更新页面显示
            totalRowLabel.textContent = `车辆租金 (${validDays}天)`;
            
            // 格式化金额显示（添加千位分隔符）
            const formattedCost = totalCost.toLocaleString('zh-CN', {
                minimumFractionDigits: 0,
                maximumFractionDigits: 0
            });
            
            totalRowValue.textContent = `¥${formattedCost}`;
            totalAmountValue.textContent = `¥${formattedCost}`;
            console.log(`计算租金: 日租金=${dailyRate}, 天数=${validDays}, 总租金=${totalCost}`);
        } else {
            // 如果日期不完整或不合理，重置显示为0
            totalRowLabel.textContent = '车辆租金 (0天)';
            totalRowValue.textContent = '¥0';
            totalAmountValue.textContent = '¥0';
            console.log('日期不完整或不合理，租金重置为0');
        }
    } catch (error) {
        console.error('更新租用信息时发生错误:', error);
        // 发生错误时，确保租金显示为0
        try {
            const totalRowLabel = document.querySelector('.total-row .total-label');
            const totalRowValue = document.querySelector('.total-row .total-value');
            const totalAmountValue = document.querySelector('.total-amount div:last-child');
            
            if (totalRowLabel) totalRowLabel.textContent = '车辆租金 (0天)';
            if (totalRowValue) totalRowValue.textContent = '¥0';
            if (totalAmountValue) totalAmountValue.textContent = '¥0';
        } catch (innerError) {
            console.error('重置租金显示时发生错误:', innerError);
        }
    }
}

/**
 * 设置日期输入框的相互限制
 */
function setupDateInputConstraints() {
    try {
        // 使用基本选择器并添加防御性检查
        const pickupDateInput = document.querySelector('input[type="date"]');
        const returnDateInput = document.querySelectorAll('input[type="date"]')[1];
        
        // 检查元素是否存在
        if (!pickupDateInput || !returnDateInput) {
            console.warn('未找到日期输入框元素');
            return;
        }
        
        // 设置最小日期为今天
        const today = new Date().toISOString().split('T')[0];
        pickupDateInput.min = today;
        returnDateInput.min = today;
        
        // 当取车日期变化时，更新还车日期的最小可选值和租用信息
        pickupDateInput.addEventListener('change', function() {
            if (this.value) {
                // 直接设置还车日期的最小可选值
                returnDateInput.min = this.value;
                
                // 验证并清除不合理的还车日期
                validateReturnDate();
            } else {
                // 如果取车日期被清除，恢复还车日期的最小限制为今天
                returnDateInput.min = today;
            }
            
            // 更新租用信息
            updateRentalInformation();
        });
        
        // 当还车日期变化时，更新取车日期的最大可选值和租用信息
        returnDateInput.addEventListener('change', function() {
            if (this.value) {
                // 设置取车日期的最大可选值
                pickupDateInput.max = this.value;
                
                // 验证并清除不合理的取车日期
                validatePickupDate();
            } else {
                // 如果还车日期被清除，移除取车日期的最大限制
                pickupDateInput.removeAttribute('max');
            }
            
            // 更新租用信息
            updateRentalInformation();
        });
        
        // 验证还车日期是否合理
        function validateReturnDate() {
            if (pickupDateInput.value && returnDateInput.value && returnDateInput.value < pickupDateInput.value) {
                returnDateInput.value = '';
                alert('还车日期不能早于取车日期');
                updateRentalInformation();
            }
        }
        
        // 验证取车日期是否合理
        function validatePickupDate() {
            if (pickupDateInput.value && returnDateInput.value && pickupDateInput.value > returnDateInput.value) {
                pickupDateInput.value = '';
                alert('取车日期不能晚于还车日期');
                updateRentalInformation();
            }
        }
        
        // 添加额外的日期选择验证
        pickupDateInput.addEventListener('blur', validatePickupDate);
        returnDateInput.addEventListener('blur', validateReturnDate);
    } catch (error) {
        console.error('设置日期限制时发生错误:', error);
    }
}

// 认证相关函数已被移除，不再提供登录弹窗功能
// 用户认证应在页面加载前完成，无需在此处进行认证处理

/**
 * 从URL中获取所有车辆参数
 * @returns {Object} - 包含所有车辆参数的对象
 */
function getCarParamsFromUrl() {
    const urlParams = new URLSearchParams(window.location.search);
    return {
        carId: urlParams.get('carId'),
        brand: urlParams.get('brand') ? decodeURIComponent(urlParams.get('brand')) : '',
        model: urlParams.get('model') ? decodeURIComponent(urlParams.get('model')) : '',
        color: urlParams.get('color') ? decodeURIComponent(urlParams.get('color')) : '',
        dailyRate: urlParams.get('dailyRate') ? parseFloat(urlParams.get('dailyRate')) : 0,
        licensePlate: urlParams.get('licensePlate') ? decodeURIComponent(urlParams.get('licensePlate')) : '',
        status: urlParams.get('status') ? parseInt(urlParams.get('status')) : 0,
        // 新增vehicle_instances表相关字段
        seatCount: urlParams.get('seatCount') ? parseInt(urlParams.get('seatCount')) : 5,
        powerType: urlParams.get('powerType') ? decodeURIComponent(urlParams.get('powerType')) : '自动',
        rentalCount: urlParams.get('rentalCount') ? parseInt(urlParams.get('rentalCount')) : 0,
        availableStart: urlParams.get('availableStart') ? decodeURIComponent(urlParams.get('availableStart')) : '',
        availableEnd: urlParams.get('availableEnd') ? decodeURIComponent(urlParams.get('availableEnd')) : ''
    };
}

/**
 * 获取状态显示文本
 * @param {number} status - 车辆状态(0=可租用，1=已租出，2=维护中)
 */
function getStatusText(status) {
    const statusMap = {
        0: '可租用',
        1: '已租出',
        2: '维护中'
    };
    return statusMap[status] || '未知';
}

/**
 * 格式化日期时间显示
 * @param {string|Date} date - 日期对象或日期字符串
 * @returns {string} 格式化后的日期字符串
 */
function formatDate(date) {
    if (!date) return '--';
    try {
        const d = new Date(date);
        const year = d.getFullYear();
        const month = String(d.getMonth() + 1).padStart(2, '0');
        const day = String(d.getDate()).padStart(2, '0');
        return `${year}-${month}-${day}`;
    } catch (error) {
        return date.toString().split('T')[0] || '--';
    }
}

/**
 * 根据URL参数加载车辆详情
 * @param {Object} urlParams - 包含所有车辆参数的对象
 */
function loadCarDetails(urlParams) {
    console.log('正在加载车辆ID为', urlParams.carId, '的详情');
    
    try {
        // 只使用URL参数中的车辆信息
        const carDetails = createCarDetailsFromUrlParams(urlParams);
        
        // 更新页面显示
        updateCarDetailsOnPage(carDetails);
    } catch (error) {
        console.error('加载车辆详情失败:', error);
        // 显示错误提示给用户
        alert('加载车辆信息失败，请稍后重试');
    }
}

/**
 * 根据URL参数创建车辆详情对象
 * @param {Object} urlParams - URL参数对象
 * @returns {Object} - 车辆详情对象
 */
function createCarDetailsFromUrlParams(urlParams) {
    return {
        id: urlParams.carId,
        fullName: urlParams.brand && urlParams.model ? `${urlParams.brand} ${urlParams.model}` : `车辆${urlParams.carId}`,
        brand: urlParams.brand || '',
        model: urlParams.model || '',
        licensePlate: urlParams.licensePlate || '',
        color: urlParams.color || '',
        dailyPrice: urlParams.dailyRate || 0,
        status: urlParams.status || 0,
        statusText: getStatusText(urlParams.status || 0),
        // 新增vehicle_instances表相关字段
        seatCount: urlParams.seatCount || 5,
        powerType: urlParams.powerType || '自动',
        rentalCount: urlParams.rentalCount || 0,
        availableStart: urlParams.availableStart || '',
        availableEnd: urlParams.availableEnd || '',
        imageUrl: '../img/car.jpg'
    };
}



/**
 * 更新页面上的车辆详情显示
 * @param {Object} carDetails - 从URL参数解析的车辆详情对象
 */
function updateCarDetailsOnPage(carDetails) {
    console.log('更新页面车辆详情:', carDetails);
    
    // 更新车辆图片
    const carImage = document.querySelector('.car-gallery img');
    if (carImage && carDetails.imageUrl) {
        carImage.src = carDetails.imageUrl;
        carImage.style.display = 'block';
    }
    
    // 更新车辆标题
    const carTitle = document.querySelector('.car-title');
    if (carTitle && carDetails.fullName) {
        carTitle.textContent = carDetails.fullName;
    }
    
    // 更新车辆规格信息 - 显示从URL参数中获取到的所有车辆信息
    // vehicle_info表相关信息
    if (carDetails.licensePlate) {
        updateSpecValue('车牌号码', carDetails.licensePlate);
    }
    
    if (carDetails.color) {
        updateSpecValue('车辆颜色', carDetails.color);
    }
    
    if (carDetails.statusText) {
        updateSpecValue('车辆状态', carDetails.statusText);
    }
    
    // vehicle_instances表相关信息
    if (carDetails.seatCount) {
        updateSpecValue('座位数量', `${carDetails.seatCount}座`);
    }
    
    if (carDetails.powerType) {
        updateSpecValue('动力类型', carDetails.powerType);
    } else {
        updateSpecValue('动力类型', '--');
    }
    
    if (carDetails.rentalCount > 0) {
        updateSpecValue('租用次数', `${carDetails.rentalCount}次`);
    } else {
        updateSpecValue('租用次数', '0次');
    }
    
    if (carDetails.availableStart) {
        updateSpecValue('可租开始时间', formatDate(carDetails.availableStart));
    } else {
        updateSpecValue('可租开始时间', '暂无信息');
    }
    
    if (carDetails.availableEnd) {
        updateSpecValue('可租结束时间', formatDate(carDetails.availableEnd));
    } else {
        updateSpecValue('可租结束时间', '暂无信息');
    }
    
    // 更新价格信息
    if (carDetails.dailyPrice > 0) {
        const priceValue = document.querySelector('.price-value');
        if (priceValue) {
            priceValue.textContent = `¥${carDetails.dailyPrice}/天`;
        }
    }
}

/**
 * 更新指定规格项的值
 * @param {string} specLabel - 规格标签
 * @param {string} specValue - 规格值
 */
function updateSpecValue(specLabel, specValue) {
    // 查找所有规格标签
    const specLabels = document.querySelectorAll('.spec-label');
    
    // 遍历所有规格标签，找到匹配的标签
    specLabels.forEach(label => {
        if (label.textContent === specLabel) {
            // 找到匹配的标签后，获取其父元素（.spec-item）
            const specItem = label.closest('.spec-item');
            if (specItem) {
                // 在规格项中找到值元素并更新
                const valueElement = specItem.querySelector('.spec-value');
                if (valueElement) {
                    valueElement.textContent = specValue;
                }
            }
        }
    });
}

/**
 * 处理预约提交
 */
function handleReservationSubmit() {
    console.log('提交预约信息');
    
    // 简单的表单验证
    const dateInputs = document.querySelectorAll('input[type="date"]');
    const pickupDate = dateInputs[0] ? dateInputs[0].value : '';
    const returnDate = dateInputs[1] ? dateInputs[1].value : '';
    const timeInputs = document.querySelectorAll('input[type="time"]');
    const pickupTime = timeInputs[0] ? timeInputs[0].value : '';
    const returnTime = timeInputs[1] ? timeInputs[1].value : '';
    
    if (!pickupDate) {
        alert('请选择取车日期');
        return;
    }
    
    if (!returnDate) {
        alert('请选择还车日期');
        return;
    }
    
    // 获取认证令牌 - 使用与checkUserLoginStatus函数相同的方式
    const token = window.utils && window.utils.cookie && window.utils.cookie.getAuthToken ? 
                 window.utils.cookie.getAuthToken() : null;
    
    // 不再要求用户登录，继续处理请求（后端会验证token有效性）
    
    // 获取车辆ID和总价格
    const urlParams = getCarParamsFromUrl();
    const vehicleId = urlParams.carId;
    
    // 构建完整的开始和结束时间字符串
    const startTimeStr = `${pickupDate} ${pickupTime}:00`;
    const endTimeStr = `${returnDate} ${returnTime}:00`;
    
    // 获取总租金（从页面显示中获取）
    const totalAmountValue = document.querySelector('.total-amount div:last-child');
    if (!totalAmountValue) {
        alert('获取总租金失败');
        return;
    }
    
    const totalPriceText = totalAmountValue.textContent;
    const totalPriceMatch = totalPriceText.match(/¥([\d,]+)/);
    
    // 设置默认总租金为0
    let totalPrice = 0;
    if (totalPriceMatch && totalPriceMatch[1]) {
        // 移除千位分隔符并转换为数字
        totalPrice = parseFloat(totalPriceMatch[1].replace(/,/g, ''));
    }
    
    console.log('计算的总租金:', totalPrice);
    
    // 构建请求数据
    const requestData = {
        vehicleId: vehicleId,
        startTime: startTimeStr,
        endTime: endTimeStr,
        totalPrice: totalPrice
    };
    
    console.log('请求数据:', requestData);
    
    // 发送创建订单请求
    console.log('获取的令牌:', token);
    
    // 构建请求头
    const headers = {
        'Authorization': token ? `Bearer ${token}` : ''
    };
    
    // 使用window.utils.api.post方法发送请求，确保请求被发送到正确的后端端口
    window.utils.api.post('/api/order/create', requestData, { headers })
    .then(data => {
        console.log('创建订单响应:', data);
        
        // 处理返回的状态码
        if (data.code === 6000) {
            // 订单创建成功，显示支付确认弹窗
            showPaymentConfirmation(data.orderId, token);
        } else {
            // 显示错误信息
            alert(data.message || '创建订单失败');
        }
    })
    .catch(error => {
        console.error('创建订单时发生错误:', error);
        alert('创建订单失败，请稍后重试\n' + error.message);
    });
}

/**
 * 显示支付确认弹窗
 * @param {number} orderId - 订单ID
 * @param {string} token - 用户令牌
 */
function showPaymentConfirmation(orderId, token) {
    if (confirm('请支付订单')) {
        // 用户点击确定，发送支付请求
        processPayment(orderId, token);
    } else {
        // 用户点击取消，发送取消订单请求
        cancelOrder(orderId, token);
    }
}

/**
 * 处理支付请求
 * @param {number} orderId - 订单ID
 * @param {string} token - 用户令牌
 */
function processPayment(orderId, token) {
    console.log('处理支付请求，订单ID:', orderId);
    
    // 构建请求头
    const headers = {
        'Authorization': token ? `Bearer ${token}` : ''
    };
    
    // 使用window.utils.api.post方法发送请求
    window.utils.api.post('/api/order/pay', { orderId: orderId }, { headers })
    .then(data => {
        console.log('支付响应数据:', data);
        
        // 处理返回的状态码
        if (data.code === 6001) {
            // 支付成功
            console.log('支付成功');
            alert('支付成功！');
            window.location.href = '../index.html';
        } else if (data.code === 6002) {
            // 支付失败
            alert('支付失败');
            window.location.href = '../index.html';
        } else {
            // 显示错误信息
            alert(data.message || '支付处理失败');
        }
    })
    .catch(error => {
        console.error('支付时发生错误:', error);
        alert('支付失败，请稍后重试\n' + error.message);
    });
}

/**
 * 取消订单
 * @param {number} orderId - 订单ID
 * @param {string} token - 用户令牌
 */
function cancelOrder(orderId, token) {
    console.log('取消订单，订单ID:', orderId);
    
    // 构建请求头
    const headers = {
        'Authorization': token ? `Bearer ${token}` : ''
    };
    
    // 使用window.utils.api.post方法发送请求
    window.utils.api.post('/api/order/cancel', { orderId: orderId }, { headers })
    .then(data => {
        console.log('取消订单响应数据:', data);
        
        // 处理返回的状态码
        if (data.code === 6002) {
            // 取消成功
            alert('取消成功');
            window.location.href = '../index.html';
        } else {
            // 显示错误信息
            alert(data.message || '取消订单失败');
        }
    })
    .catch(error => {
        console.error('取消订单时发生错误:', error);
        alert('取消订单失败，请稍后重试\n' + error.message);
    });
}